package com.dingreading.cloud.subject.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.dingreading.cloud.subject.dto.CourseTrainTypesDto;
import com.dingreading.cloud.subject.entity.CourseTypes;
import org.apache.commons.collections4.CollectionUtils;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class CourseTreeJsonUtil {

    /**
     * 创建一颗树，以json字符串形式返回
     *
     * @param list 原始数据列表
     * @return 树
     */
    public static JSONArray createCourseTypesTreeJson(List<CourseTypes> list) {
        JSONArray rootArray = new JSONArray();

        LinkedHashMap<Long, List<CourseTypes>> map = list.stream().collect(
                Collectors.groupingBy(CourseTypes::getMainId, LinkedHashMap::new, Collectors.toList()));
        if (map != null && map.size() > 0) {
            for (Map.Entry<Long, List<CourseTypes>> entry : map.entrySet()) {
                List<CourseTypes> courseTypesList = entry.getValue();
                if (CollectionUtils.isNotEmpty(courseTypesList)) {
                    CourseTypes mainObj = new CourseTypes();
                    List<CourseTypes> childList = new ArrayList<>();
                    for (CourseTypes courseTypes : courseTypesList) {
                        if (courseTypes.getParentId() == null || courseTypes.getParentId() == 0) {
                            mainObj = courseTypes;
                        } else {
                            childList.add(courseTypes);
                        }
                    }
                    JSONObject rootObj = createBranch(mainObj, childList);
                    rootArray.add(rootObj);
                }
            }
        }
        return rootArray;
    }

    /**
     * 递归创建分支节点Json对象
     *
     * @param courseTypesList 创建树的原始数据
     * @param currentNode     当前节点getSubject
     * @return 当前节点与该节点的子节点json对象
     */
    private static JSONObject createBranch(CourseTypes currentNode, List<CourseTypes> courseTypesList) {
        /*
         * 将javabean对象解析成为JSON对象
         */
        JSONObject currentObj = JSONObject.parseObject(JSON.toJSONString(currentNode, SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteDateUseDateFormat));
        JSONArray childArray = new JSONArray();
        /*
         * 循环遍历原始数据列表，判断列表中某对象的父id值是否等于当前节点的id值，
         * 如果相等，进入递归创建新节点的子节点，直至无子节点时，返回节点，并将该 节点放入当前节点的子节点列表中
         */
        for (CourseTypes newNode : courseTypesList) {
            if (newNode.getParentId() != null && newNode.getParentId().equals(currentNode.getId())) {
                JSONObject childObj = createBranch(newNode, courseTypesList);
                childArray.add(childObj);
            }
        }

        /*
         * 判断当前子节点数组是否为空，不为空将子节点数组加入children字段中
         */
        currentObj.put("childList", childArray);
        return currentObj;
    }


    public static JSONArray createChildCourseTypesTreeJson(List<CourseTypes> list) {
        JSONArray rootArray = new JSONArray();
        if (CollectionUtils.isNotEmpty(list)) {
            List<CourseTypes> mainList = new ArrayList<>();
            List<CourseTypes> childList = new ArrayList<>();
            for (CourseTypes types : list) {
                if (types.getLevelIndex().equals(1)) {
                    mainList.add(types);
                } else {
                    childList.add(types);
                }
            }

            for (CourseTypes mainCourseTypes : mainList) {
                // 筛选获取下级的记录
                JSONObject rootObj = createChildBranch(mainCourseTypes, childList);
                rootArray.add(rootObj);
            }

        }
        return rootArray;
    }

    /**
     * 递归创建分支节点Json对象
     *
     * @param courseTypesList 创建树的原始数据
     * @param currentNode     当前节点getSubject
     * @return 当前节点与该节点的子节点json对象
     */
    private static JSONObject createChildBranch(CourseTypes currentNode, List<CourseTypes> courseTypesList) {
        /*
         * 将javabean对象解析成为JSON对象
         */
        JSONObject currentObj = JSONObject.parseObject(JSON.toJSONString(currentNode, SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteDateUseDateFormat));
        JSONArray childArray = new JSONArray();
        /*
         * 循环遍历原始数据列表，判断列表中某对象的父id值是否等于当前节点的id值，
         * 如果相等，进入递归创建新节点的子节点，直至无子节点时，返回节点，并将该 节点放入当前节点的子节点列表中
         */
        if (CollectionUtils.isNotEmpty(courseTypesList)) {
            for (CourseTypes newNode : courseTypesList) {
                if (newNode.getParentId() != null && newNode.getLevelIndex() > 1 && newNode.getParentId().equals(currentNode.getId())) {
                    JSONObject childObj = createChildBranch(newNode, courseTypesList);
                    childArray.add(childObj);
                }
            }
        }

        /*
         * 判断当前子节点数组是否为空，不为空将子节点数组加入children字段中
         */
        currentObj.put("childList", childArray);
        return currentObj;
    }


    public static JSONArray createChildCourseTrainTypesTreeJson(List<CourseTrainTypesDto> list) {
        JSONArray rootArray = new JSONArray();
        if (CollectionUtils.isNotEmpty(list)) {
            List<CourseTrainTypesDto> mainList = new ArrayList<>();
            List<CourseTrainTypesDto> childList = new ArrayList<>();
            for (CourseTrainTypesDto types : list) {
                if (types.getLevelIndex().equals(1)) {
                    mainList.add(types);
                } else {
                    childList.add(types);
                }
            }

            for (CourseTrainTypesDto mainCourseTypes : mainList) {
                // 筛选获取下级的记录
                JSONObject rootObj = createChildTrainBranch(mainCourseTypes, childList);
                rootArray.add(rootObj);
            }

        }
        return rootArray;
    }

    /**
     * 递归创建分支节点Json对象
     *
     * @param courseTypesList 创建树的原始数据
     * @param currentNode     当前节点getSubject
     * @return 当前节点与该节点的子节点json对象
     */
    private static JSONObject createChildTrainBranch(CourseTrainTypesDto currentNode, List<CourseTrainTypesDto> courseTypesList) {
        /*
         * 将javabean对象解析成为JSON对象
         */
        JSONObject currentObj = JSONObject.parseObject(JSON.toJSONString(currentNode, SerializerFeature.WriteMapNullValue,
                                                                         SerializerFeature.WriteDateUseDateFormat));
        JSONArray childArray = new JSONArray();
        /*
         * 循环遍历原始数据列表，判断列表中某对象的父id值是否等于当前节点的id值，
         * 如果相等，进入递归创建新节点的子节点，直至无子节点时，返回节点，并将该 节点放入当前节点的子节点列表中
         */
        if (CollectionUtils.isNotEmpty(courseTypesList)) {
            for (CourseTrainTypesDto newNode : courseTypesList) {
                if (newNode.getParentId() != null && newNode.getLevelIndex() > 1 && newNode.getParentId().equals(currentNode.getId())) {
                    JSONObject childObj = createChildTrainBranch(newNode, courseTypesList);
                    childArray.add(childObj);
                }
            }
        }

        /*
         * 判断当前子节点数组是否为空，不为空将子节点数组加入children字段中
         */
        currentObj.put("childList", childArray);
        return currentObj;
    }
}
